package com.specter.dev.docs.execute;

import com.specter.utils.StringUtils;
import com.thoughtworks.qdox.model.JavaClass;
import com.thoughtworks.qdox.model.JavaField;

public class JApiInputExeUtils {

    private JApiInputExeUtils() {
    }

    /**
     * 判断是否为Servlet相关参数
     * 
     * @param cls 对应的类
     * @return 是否为WEB参数
     */
    public static boolean isIgnore(JavaClass cls) {
        switch (cls.getCanonicalName()) {
            case "javax.servlet.http.HttpServletRequest":
            case "javax.servlet.http.HttpServletResponse":
            case "org.springframework.ui.Model":
            case "org.springframework.ui.ModelMap":
            case "org.springframework.web.servlet.ModelAndView":
            case "org.springframework.web.context.request.WebRequest":
                return true;
            default:
                return false;
        }
    }

    public static boolean isIgnore(JavaField field) {
        String fieldName = field.getName();
        // 1. JAR读取时错误
        if (fieldName.startsWith("this$")) {
            return true;
        }
        // 2. 按照命名规则
        if (fieldName.startsWith("_") || fieldName.endsWith("_")) {
            return true;
        }
        // 3. 按照名称列表黑名单
        switch (fieldName) {
            case "serialVersionUID":
                return true;
            default:
                return false;
        }
        // 4. 按照字段注解
    }

    /**
     * 判断是否为基础数据类型
     * 
     * @param cls 对应的类
     * @return 是否为基础类型
     */
    public static boolean isPrimitive(JavaClass cls) {
        if (cls.isPrimitive()) {
            return true;
        }
        switch (cls.getCanonicalName()) {
            case "java.lang.Byte":
            case "java.lang.Short":
            case "java.lang.Long":
            case "java.lang.Float":
            case "java.lang.Double":
            case "java.lang.Integer":
            case "java.lang.String":
            case "java.lang.Boolean":
            case "java.util.Date":
            case "java.sql.Date":
            case "java.sql.Clob":
            case "java.sql.Blob":
            case "java.sql.Time":
            case "java.sql.Timestamp":
            case "java.math.BigDecimal":
            case "java.math.BigInteger":
            case "java.io.Serializable":
                return true;
            default:
                return false;
        }
    }

    /**
     * 通过简写名字判断是否为基础类型
     * 
     * @param clsName 简写名字
     * @return 是否为基础类型
     */
    public static boolean isPrimitive(String clsName) {
        if (clsName == null) {
            return false;
        }
        clsName = StringUtils.capitalize(clsName);
        switch (clsName) {
            case "Byte":
            case "Short":
            case "Long":
            case "Float":
            case "Double":
            case "Int":
            case "Integer":
            case "String":
            case "Boolean":
            case "Date":
            case "Clob":
            case "Blob":
            case "Time":
            case "Timestamp":
            case "BigDecimal":
            case "BigInteger":
            case "Serializable":
                return true;
            default:
                return false;
        }
    }

    /**
     * 判断是否为Map类型
     * 
     * @param cls 对应的类
     * @return 是否为Map类型
     */
    public static boolean isMap(JavaClass cls) {
        if (cls.isA("java.util.Map")) {
            return true;
        }
        switch (cls.getCanonicalName()) {
            case "java.util.Map":
                return true;
            default:
                return false;
        }
    }

    /**
     * 判断是否为集合类型
     * 
     * @param cls 对应的类
     * @return 是否为结合类型
     */
    public static boolean isCollection(JavaClass cls) {
        if (cls.isA("java.util.Collection")) {
            return true;
        }
        switch (cls.getCanonicalName()) {
            case "java.util.Collection":
            case "java.util.List":
                return true;
            default:
                return false;
        }
    }

    /**
     * 判断是否为集合类型
     * 
     * @param cls 对应的类
     * @return 是否为结合类型
     */
    public static boolean isCollection(String clsName) {
        if (clsName == null) {
            return false;
        }
        clsName = StringUtils.capitalize(clsName);
        switch (clsName) {
            case "Array":
            case "List":
                return true;
            default:
                return false;
        }
    }

    /**
     * 判断是否为位置对象
     * 
     * @param cls 对应的类
     * @return 是否为位置对象
     */
    public static boolean isObject(JavaClass cls) {
        if (cls == null || "java.lang.Object".equals(cls.getCanonicalName())) {
            return true;
        }
        return false;
    }

    /**
     * 通过类名获取主要的泛型名称
     * 
     * @param cls 对应的类
     * @return 泛型的全名称
     */
    public static String getGenericName(JavaClass cls) {
        String clsName = cls.getGenericFullyQualifiedName();
        if (clsName.matches(".+<.+>")) {
            String name = clsName.substring(clsName.indexOf("<") + 1, clsName.indexOf(">"));
            if (isMap(cls)) {
                name = name.substring(name.indexOf(",") + 1);
            }
            return name;
        }
        return null;
    }
}